/**
 * 智能诊断页面脚本
 * 处理AI聊天功能和聊天历史管理
 */
document.addEventListener('DOMContentLoaded', function() {
    // 使用后端API，无需在前端存储API密钥
    
    // DOM元素
    const messageInput = document.getElementById('messageInput');
    const sendMessageBtn = document.getElementById('sendMessageBtn');
    const chatMessages = document.getElementById('chatMessages');
    const clearChatBtn = document.getElementById('clearChatBtn');
    const exportReportBtn = document.getElementById('exportReportBtn');
    const helpGuideBtn = document.getElementById('helpGuideBtn');
    const closeHelpModal = document.getElementById('closeHelpModal');
    
    // 帮助指南模态框
    const helpGuideModal = new Modal('helpGuideModal');
    
    // 当前会话信息
    let currentUser = null;
    let currentSessionId = '';
    
    // 检查用户是否已登录
    if (!window.isAuthenticated()) {
        console.warn('用户未登录，将重定向到登录页面');
        window.location.href = '/login?redirect=' + encodeURIComponent(window.location.pathname);
        return;
    }
    
    // 初始化应用
    initializeApp();
    
    // 绑定事件
    sendMessageBtn.addEventListener('click', sendMessage);
    messageInput.addEventListener('keydown', function(e) {
        // 当按下Enter键且未按Shift键时发送消息
        if (e.key === 'Enter' && !e.shiftKey) {
            e.preventDefault();
            sendMessage();
        }
    });
    
    // 关闭帮助模态框按钮点击事件
    if (closeHelpModal) {
        closeHelpModal.addEventListener('click', () => {
            helpGuideModal.close();
        });
    }
    
    // 设置帮助模态框确认按钮
    helpGuideModal.setConfirmHandler('confirmHelpGuide', () => {
        helpGuideModal.close();
    });
    
    // 清除聊天记录按钮
    if (clearChatBtn) {
        clearChatBtn.addEventListener('click', clearChat);
    }
    
    // 导出报告按钮
    if (exportReportBtn) {
        exportReportBtn.addEventListener('click', exportReport);
    }
    
    // 帮助指南按钮
    if (helpGuideBtn) {
        helpGuideBtn.addEventListener('click', showHelpGuide);
    }
    
    /**
     * 初始化应用
     * 按顺序执行初始化步骤，确保用户信息先加载完成
     */
    async function initializeApp() {
        try {
            // 第一步：获取用户信息
            await loadUserInfo();
            
            // 第二步：获取会话ID
            await loadSessionId();
            
            // 第三步：加载聊天历史
            await loadChatHistory();
            
            // 第四步：显示首次访问帮助指南（如果需要）
            checkFirstVisit();
            
            console.log("应用初始化完成，用户:", currentUser, "会话ID:", currentSessionId);
        } catch (error) {
            console.error("应用初始化失败:", error);
            alert("初始化应用失败: " + error.message);
        }
    }
    
    /**
     * 加载用户信息
     * 返回Promise以便等待加载完成
     */
    async function loadUserInfo() {
        return new Promise((resolve, reject) => {
            // 尝试从本地存储获取用户信息
            const userInfoStr = localStorage.getItem('userInfo');
            
            if (userInfoStr) {
                try {
                    const userInfo = JSON.parse(userInfoStr);
                    console.log("从localStorage获取到用户信息:", userInfo);
                    
                    if (userInfo && userInfo.userId) {
                        // 用户信息有效，初始化currentUser
                        currentUser = {
                            id: userInfo.userId,
                            name: userInfo.realName || userInfo.username,
                            initials: getUserInitials(userInfo.realName || userInfo.username)
                        };
                        console.log("已设置当前用户:", currentUser);
                        resolve(currentUser);
                        return;
                    }
                } catch (e) {
                    console.error("解析localStorage中的用户信息失败:", e);
                }
            }
            
            // 如果本地存储没有有效的用户信息，从服务器刷新
            console.log("从服务器刷新用户信息");
            window.refreshUserInfo()
                .then(userInfo => {
                    console.log("服务器返回用户信息:", userInfo);
                    
                    if (!userInfo || !userInfo.userId) {
                        reject(new Error("服务器未返回有效的用户信息"));
                        return;
                    }
                    
                    // 设置用户信息
                    currentUser = {
                        id: userInfo.userId,
                        name: userInfo.realName || userInfo.username,
                        initials: getUserInitials(userInfo.realName || userInfo.username)
                    };
                    
                    console.log("已设置当前用户:", currentUser);
                    resolve(currentUser);
                })
                .catch(error => {
                    console.error("刷新用户信息失败:", error);
                    reject(error);
                });
        });
    }
    
    /**
     * 加载会话ID
     * 返回Promise以便等待加载完成
     */
    async function loadSessionId() {
        return new Promise((resolve, reject) => {
            if (!currentUser || !currentUser.id) {
                reject(new Error("无法获取会话ID，用户未初始化"));
                return;
            }
            
            const sessionKey = `chat_session_${currentUser.id}`;
            const sessionId = localStorage.getItem(sessionKey);
            
            console.log("从localStorage获取会话ID:", sessionId, "存储键:", sessionKey);
            
            if (sessionId) {
                currentSessionId = sessionId;
                console.log("已设置当前会话ID:", currentSessionId);
                resolve(sessionId);
            } else {
                console.log("没有找到会话ID，将在加载聊天历史时创建新会话");
                resolve(null);
            }
        });
    }
    
    /**
     * 检查是否是首次访问，如果是则显示帮助指南
     */
    function checkFirstVisit() {
        const hasVisitedBefore = localStorage.getItem('hasVisitedDiagnosisPage');
        if (!hasVisitedBefore) {
            // 设置访问标记
            localStorage.setItem('hasVisitedDiagnosisPage', 'true');
            // 延迟显示帮助指南，让页面先加载完成
            setTimeout(() => {
                showHelpGuide();
            }, 1000);
        }
    }
    
    /**
     * 获取当前登录用户ID
     * 直接从currentUser对象获取
     */
    function getUserId() {
        if (!currentUser) {
            console.warn('用户信息未初始化');
            return null;
        }
        return currentUser.id;
    }
    
    /**
     * 获取当前登录用户名
     * 直接从currentUser对象获取
     */
    function getUserName() {
        if (!currentUser) {
            return '访客';
    }
        return currentUser.name;
    }
    
    /**
     * 保存当前会话ID到localStorage
     * @param {string} sessionId - 会话ID
     */
    function saveSessionId(sessionId) {
        if (!currentUser || !currentUser.id) {
            console.error("无法保存会话ID，用户ID为空");
            return;
        }
        
        const sessionKey = `chat_session_${currentUser.id}`;
        console.log("保存会话ID:", sessionId, "对应用户:", currentUser.id, "存储键:", sessionKey);
        localStorage.setItem(sessionKey, sessionId);
        currentSessionId = sessionId;
    }
    
    /**
     * 加载聊天历史记录
     */
    async function loadChatHistory() {
        try {
            // 确保用户已登录
            if (!currentUser || !currentUser.id) {
                console.warn('用户未登录，无法加载聊天历史');
                return;
            }
            
            console.log("正在尝试加载聊天历史，用户ID:", currentUser.id, "会话ID:", currentSessionId);
            
            // 如果没有会话ID，创建新的会话
            if (!currentSessionId) {
                console.log("没有会话ID，正在创建新会话");
                // 调用API创建新会话
                const response = await fetch('/api/chat-history/new-session', {
                    method: 'POST',
                    headers: {
                        'Content-Type': 'application/json'
                    }
                });
                
                if (!response.ok) {
                    const errorText = await response.text();
                    console.error("创建会话失败:", errorText);
                    throw new Error(`HTTP error! status: ${response.status}`);
                }
                
                const data = await response.json();
                console.log("创建新会话响应:", data);
                
                if (data.code === 200) {
                    saveSessionId(data.data.sessionId);
                    console.log("已保存新会话ID:", data.data.sessionId);
                }
                
                // 新会话不需要加载历史记录
                return;
            }
            
            // 调用API获取聊天历史
            console.log("正在获取聊天历史, 请求URL:", `/api/chat-history/${currentUser.id}/${currentSessionId}`);
            const response = await fetch(`/api/chat-history/${currentUser.id}/${currentSessionId}`);
            
            if (!response.ok) {
                const errorText = await response.text();
                console.error("获取聊天历史失败, 状态码:", response.status, "错误:", errorText);
                throw new Error(`HTTP error! status: ${response.status}`);
            }
            
            const data = await response.json();
            console.log("获取聊天历史响应:", data);
            
            if (data.code !== 200) {
                console.warn('加载聊天历史失败:', data.message);
                return;
            }
            
            // 清除现有的聊天消息（保留初始欢迎消息）
            const welcomeMessage = chatMessages.querySelector('.message');
            
            // 显示历史消息
            const messages = data.data.messages;
            console.log("获取到的历史消息数量:", messages ? messages.length : 0);
            
            if (messages && messages.length > 0) {
                // 如果有历史消息，清除所有消息并重新添加
                chatMessages.innerHTML = '';
                
                messages.forEach(msg => {
                    if (msg.type === 'user') {
                        // 显示用户消息
                        const messageHtml = `
                            <div class="message user-message">
                                <div class="message-content">
                                    <div class="message-text">
                                        <p>${formatMessageText(msg.content)}</p>
                                    </div>
                                    <div class="message-time">${msg.formattedTime}</div>
                                </div>
                                <div class="message-avatar">
                                    <span>${currentUser.initials}</span>
                                </div>
                            </div>
                        `;
                        chatMessages.insertAdjacentHTML('beforeend', messageHtml);
                    } else if (msg.type === 'ai') {
                        // 显示AI消息
                        const messageHtml = `
                            <div class="message ai-message">
                                <div class="message-avatar ai-avatar">
                                    <img src="/static/images/ai-doctor-avatar.png" alt="AI医生" onerror="this.src='/static/images/default-ai-avatar.svg';this.onerror='';">
                                </div>
                                <div class="message-content">
                                    <div class="message-text">
                                        <p>${formatMessageText(msg.content)}</p>
                                    </div>
                                    <div class="message-time">${msg.formattedTime}</div>
                                </div>
                            </div>
                        `;
                        chatMessages.insertAdjacentHTML('beforeend', messageHtml);
                    }
                });
                
                // 滚动到底部
                scrollToBottom();
            } else if (welcomeMessage) {
                // 如果没有历史消息，保留欢迎消息
                chatMessages.innerHTML = '';
                chatMessages.appendChild(welcomeMessage);
            }
        } catch (error) {
            console.error('加载聊天历史失败:', error);
            // 失败时不影响用户体验，只是不显示历史记录
        }
    }
    
    /**
     * 发送消息到AI并显示响应
     */
    async function sendMessage() {
        const message = messageInput.value.trim();
        if (!message) return;
        
        // 检查用户ID是否有效
        if (!currentUser || !currentUser.id) {
            alert('用户未登录，请重新登录后再试');
            window.location.href = '/login?redirect=' + encodeURIComponent(window.location.pathname);
            return;
        }
        
        // 添加用户消息到聊天区域
        appendUserMessage(message);
        
        // 清空输入框
        messageInput.value = '';
        
        // 添加AI思考指示器
        const aiMessageContainer = appendAiThinking();
        
        try {
            // 调用后端API获取AI响应
            console.log("发送消息，用户ID:", currentUser.id, "会话ID:", currentSessionId);
            const aiResponse = await callAiApi(message, currentUser.id, currentSessionId);
            
            // 移除思考指示器
            aiMessageContainer.innerHTML = '';
            
            // 添加AI回复
            appendAiMessage(aiResponse.reply, aiMessageContainer);
            
            // 保存会话ID
            if (aiResponse.sessionId) {
                console.log("从AI响应中获取到会话ID:", aiResponse.sessionId, "当前会话ID:", currentSessionId);
                
                // 如果是首次聊天或会话ID发生变更，保存新会话ID
                if (!currentSessionId || currentSessionId !== aiResponse.sessionId) {
                saveSessionId(aiResponse.sessionId);
                    console.log("已更新会话ID:", aiResponse.sessionId);
                }
            }
        } catch (error) {
            console.error('AI响应错误:', error);
            
            // 显示详细的错误消息
            aiMessageContainer.innerHTML = '';
            const errorMessage = error.message || '抱歉，AI响应出现错误，请稍后再试。';
            appendErrorMessage(errorMessage, aiMessageContainer);
            
            // 记录更详细的错误信息到控制台，帮助调试
            console.error('错误详情:', {
                message: message,
                errorType: error.name,
                errorStack: error.stack
            });
        }
    }
    
    /**
     * 添加用户消息到聊天区域
     * @param {string} message - 用户消息内容
     */
    function appendUserMessage(message) {
        const currentTime = getCurrentTime();
        
        const messageHtml = `
            <div class="message user-message">
                <div class="message-content">
                    <div class="message-text">
                        <p>${formatMessageText(message)}</p>
                    </div>
                    <div class="message-time">${currentTime}</div>
                </div>
                <div class="message-avatar">
                    <span>${currentUser.initials}</span>
                </div>
            </div>
        `;
        
        chatMessages.insertAdjacentHTML('beforeend', messageHtml);
        scrollToBottom();
    }
    
    /**
     * 添加AI思考指示器
     * @returns {HTMLElement} - 添加的消息容器元素
     */
    function appendAiThinking() {
        const messageHtml = `
            <div class="message ai-message">
                <div class="message-avatar ai-avatar">
                    <img src="/static/images/ai-doctor-avatar.png" alt="AI医生" onerror="this.src='/static/images/default-ai-avatar.svg';this.onerror='';">
                </div>
                <div class="message-content">
                    <div class="message-text thinking">
                        <p>AI正在思考中<span class="dot-1">.</span><span class="dot-2">.</span><span class="dot-3">.</span></p>
                    </div>
                </div>
            </div>
        `;
        
        chatMessages.insertAdjacentHTML('beforeend', messageHtml);
        scrollToBottom();
        
        // 返回最后添加的消息元素的内容区域
        const messages = chatMessages.querySelectorAll('.message');
        const lastMessage = messages[messages.length - 1];
        return lastMessage.querySelector('.message-content');
    }
    
    /**
     * 添加AI消息到聊天区域
     * @param {string} message - AI回复内容
     * @param {HTMLElement} container - 消息容器元素
     */
    function appendAiMessage(message, container) {
        const currentTime = getCurrentTime();
        
        const messageHtml = `
            <div class="message-text">
                <p>${formatMessageText(message)}</p>
            </div>
            <div class="message-time">${currentTime}</div>
        `;
        
        container.innerHTML = messageHtml;
        scrollToBottom();
    }
    
    /**
     * 添加错误消息
     * @param {string} message - 错误信息
     * @param {HTMLElement} container - 消息容器元素
     */
    function appendErrorMessage(message, container) {
        const currentTime = getCurrentTime();
        
        const messageHtml = `
            <div class="message-text error">
                <p>${message}</p>
            </div>
            <div class="message-time">${currentTime}</div>
        `;
        
        container.innerHTML = messageHtml;
        scrollToBottom();
    }
    
    /**
     * 格式化消息文本，处理换行和链接等
     * @param {string} text - 原始文本
     * @returns {string} - 格式化后的HTML
     */
    function formatMessageText(text) {
        // 将换行符转换为<br>标签
        let formattedText = text.replace(/\n/g, '<br>');
        
        // 将URL转换为可点击的链接
        formattedText = formattedText.replace(
            /(https?:\/\/[^\s]+)/g, 
            '<a href="$1" target="_blank" rel="noopener noreferrer">$1</a>'
        );
        
        return formattedText;
    }
    
    /**
     * 获取当前时间字符串
     * @returns {string} - 格式化的时间字符串
     */
    function getCurrentTime() {
        const now = new Date();
        const hours = now.getHours().toString().padStart(2, '0');
        const minutes = now.getMinutes().toString().padStart(2, '0');
        return `今天 ${hours}:${minutes}`;
    }
    
    /**
     * 获取用户姓名首字母
     * @param {string} name - 用户姓名
     * @returns {string} - 首字母(中文取第一个字，英文取首字母大写)
     */
    function getUserInitials(name) {
        if (!name || name.length === 0) return '?';
        
        // 对于中文名，取第一个字
        if (/[\u4e00-\u9fa5]/.test(name)) {
            return name.charAt(0);
        }
        
        // 对于英文名，取首字母大写
        return name.charAt(0).toUpperCase();
    }
    
    /**
     * 滚动聊天区域到底部
     */
    function scrollToBottom() {
        chatMessages.scrollTop = chatMessages.scrollHeight;
    }
    
    /**
     * 调用AI诊断API
     * @param {string} message - 用户输入的消息
     * @param {string} userId - 用户ID
     * @param {string} sessionId - 会话ID
     * @returns {Promise<Object>} - AI的响应对象
     */
    async function callAiApi(message, userId, sessionId) {
        try {
            // 检查用户ID是否有效
            if (!userId) {
                console.error('用户未登录或用户ID无效，无法发送消息');
                throw new Error('用户未登录或用户ID无效，请先登录');
            }
            
            console.log("调用AI API，参数:", {message, userId, sessionId});
            
            // 调用后端API
            const response = await fetch('/api/ai-diagnosis/chat', {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json'
                },
                body: JSON.stringify({ 
                    message, 
                    userId: Number(userId), // 确保userId是数字类型
                    sessionId 
                })
            });
            
            // 记录响应状态
            console.log("AI API响应状态:", response.status);
            
            if (!response.ok) {
                const errorText = await response.text();
                console.error("API错误响应:", errorText);
                throw new Error(`HTTP error! status: ${response.status}, 详情: ${errorText || '未知错误'}`);
            }
            
            const data = await response.json();
            console.log("AI API响应数据:", data);
            
            if (data.code !== 200) {
                throw new Error(data.message || '请求失败');
            }
            
            return data.data;
        } catch (error) {
            console.error('调用AI API失败:', error);
            throw new Error('AI服务暂时无法响应: ' + error.message);
        }
    }
    
    /**
     * 清除聊天记录
     */
    async function clearChat() {
        // 检查用户ID是否有效
        if (!currentUser || !currentUser.id) {
            console.error("无法清除聊天记录，用户未登录");
            alert("请先登录后再清除聊天记录");
            return;
        }
        
        console.log("开始清除聊天记录，用户ID:", currentUser.id, "会话ID:", currentSessionId);
        
        // 保留最初的欢迎消息
        const welcomeMessage = chatMessages.querySelector('.message');
        if (welcomeMessage) {
            chatMessages.innerHTML = '';
            chatMessages.appendChild(welcomeMessage);
        } else {
            chatMessages.innerHTML = '';
        }
        
        // 如果有会话ID，调用API清除服务器上的聊天记录
        if (currentSessionId) {
            try {
                console.log("正在调用API清除服务器聊天记录");
                const response = await fetch(`/api/chat-history/${currentUser.id}/${currentSessionId}`, {
                    method: 'DELETE'
                });
                
                if (!response.ok) {
                    const errorText = await response.text();
                    console.error('清除聊天记录失败, 状态码:', response.status, "错误:", errorText);
                } else {
                    const data = await response.json();
                    console.log("清除聊天记录响应:", data);
                }
            } catch (error) {
                console.error('清除聊天记录失败:', error);
            }
        } else {
            console.warn("没有会话ID，无法清除服务器聊天记录");
        }
        
        // 生成新的会话ID
        try {
            console.log("正在创建新会话");
            const response = await fetch('/api/chat-history/new-session', {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json'
                }
            });
            
            if (response.ok) {
                const data = await response.json();
                console.log("创建新会话响应:", data);
                
                if (data.code === 200) {
                    saveSessionId(data.data.sessionId);
                    console.log("已设置新会话ID:", data.data.sessionId);
                }
            } else {
                const errorText = await response.text();
                console.error("创建新会话失败, 状态码:", response.status, "错误:", errorText);
            }
        } catch (error) {
            console.error('创建新会话失败:', error);
        }
    }
    
    /**
     * 导出诊断报告
     */
    async function exportReport() {
        // 检查用户ID是否有效
        if (!currentUser || !currentUser.id) {
            alert('请先登录后再导出报告');
            return;
        }
        
        try {
            // 调用后端API导出报告
            const response = await fetch(`/api/ai-diagnosis/export-report/${currentUser.id}`, {
                method: 'GET',
                headers: {
                    'Content-Type': 'application/json'
                }
            });
            
            if (!response.ok) {
                const errorText = await response.text();
                console.error("导出报告失败, 状态码:", response.status, "错误:", errorText);
                throw new Error(`HTTP error! status: ${response.status}`);
            }
            
            const data = await response.json();
            console.log("导出报告响应:", data);
            
            if (data.code !== 200) {
                throw new Error(data.message || '导出报告失败');
            }
            
            // 获取报告URL并打开新窗口下载
            const reportUrl = data.data;
            window.open(reportUrl, '_blank');
        } catch (error) {
            console.error('导出报告失败:', error);
            alert('诊断报告导出失败: ' + error.message);
        }
    }
    
    /**
     * 显示帮助指南
     */
    function showHelpGuide() {
        helpGuideModal.open();
    }
}); 